<!DOCTYPE HTML>
<html lang="zh-CN">


<head>
    <meta charset="utf-8">
    <meta name="keywords" content="Java知识点（JVM篇）, Angus">
    <meta name="description" content="JavaJVM篇">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="renderer" content="webkit|ie-stand|ie-comp">
    <meta name="mobile-web-app-capable" content="yes">
    <meta name="format-detection" content="telephone=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <meta name="referrer" content="no-referrer-when-downgrade">
    <!-- Global site tag (gtag.js) - Google Analytics -->


    

    <title>Java知识点（JVM篇） | Angus</title>
    <link rel="icon" type="image/png" href="/favicon.png">

    <link rel="stylesheet" type="text/css" href="/libs/awesome/css/all.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/materialize/materialize.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/aos/aos.css">
    <link rel="stylesheet" type="text/css" href="/libs/animate/animate.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/lightGallery/css/lightgallery.min.css">
    <link rel="stylesheet" type="text/css" href="/css/matery.css">
    <link rel="stylesheet" type="text/css" href="/css/my.css">

    <script src="/libs/jquery/jquery-3.6.0.min.js"></script>

<meta name="generator" content="Hexo 6.1.0">
<style>.github-emoji { position: relative; display: inline-block; width: 1.2em; min-height: 1.2em; overflow: hidden; vertical-align: top; color: transparent; }  .github-emoji > span { position: relative; z-index: 10; }  .github-emoji img, .github-emoji .fancybox { margin: 0 !important; padding: 0 !important; border: none !important; outline: none !important; text-decoration: none !important; user-select: none !important; cursor: auto !important; }  .github-emoji img { height: 1.2em !important; width: 1.2em !important; position: absolute !important; left: 50% !important; top: 50% !important; transform: translate(-50%, -50%) !important; user-select: none !important; cursor: auto !important; } .github-emoji-fallback { color: inherit; } .github-emoji-fallback img { opacity: 0 !important; }</style>
<link rel="alternate" href="/atom.xml" title="Angus" type="application/atom+xml">
<link rel="stylesheet" href="/css/prism-tomorrow.css" type="text/css"></head>


<body>
    <header class="navbar-fixed">
    <nav id="headNav" class="bg-color nav-transparent">
        <div id="navContainer" class="nav-wrapper container">
            <div class="brand-logo">
                <a href="/" class="waves-effect waves-light">
                    
                    <img src="/medias/logo.png" class="logo-img" alt="LOGO">
                    
                    <span class="logo-span">Angus</span>
                </a>
            </div>
            

<a href="#" data-target="mobile-nav" class="sidenav-trigger button-collapse"><i class="fas fa-bars"></i></a>
<ul class="right nav-menu">
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/" class="waves-effect waves-light">
      
      <i class="fas fa-home" style="zoom: 0.6;"></i>
      
      <span>首页</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/tags" class="waves-effect waves-light">
      
      <i class="fas fa-tags" style="zoom: 0.6;"></i>
      
      <span>标签</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/categories" class="waves-effect waves-light">
      
      <i class="fas fa-bookmark" style="zoom: 0.6;"></i>
      
      <span>分类</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/archives" class="waves-effect waves-light">
      
      <i class="fas fa-archive" style="zoom: 0.6;"></i>
      
      <span>归档</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/about" class="waves-effect waves-light">
      
      <i class="fas fa-user-circle" style="zoom: 0.6;"></i>
      
      <span>关于</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/contact" class="waves-effect waves-light">
      
      <i class="fas fa-comments" style="zoom: 0.6;"></i>
      
      <span>留言板</span>
    </a>
    
  </li>
  
  <li>
    <a href="#searchModal" class="modal-trigger waves-effect waves-light">
      <i id="searchIcon" class="fas fa-search" title="搜索" style="zoom: 0.85;"></i>
    </a>
  </li>
</ul>


<div id="mobile-nav" class="side-nav sidenav">

    <div class="mobile-head bg-color">
        
        <img src="/medias/logo.png" class="logo-img circle responsive-img">
        
        <div class="logo-name">Angus</div>
        <div class="logo-desc">
            
            never give up!
            
        </div>
    </div>

    <ul class="menu-list mobile-menu-list">
        
        <li class="m-nav-item">
	  
		<a href="/" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-home"></i>
			
			首页
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/tags" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-tags"></i>
			
			标签
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/categories" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-bookmark"></i>
			
			分类
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/archives" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-archive"></i>
			
			归档
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/about" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-user-circle"></i>
			
			关于
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/contact" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-comments"></i>
			
			留言板
		</a>
          
        </li>
        
        
        <li><div class="divider"></div></li>
        <li>
            <a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="waves-effect waves-light" target="_blank">
                <i class="fab fa-github-square fa-fw"></i>Fork Me
            </a>
        </li>
        
    </ul>
</div>


        </div>

        
            <style>
    .nav-transparent .github-corner {
        display: none !important;
    }

    .github-corner {
        position: absolute;
        z-index: 10;
        top: 0;
        right: 0;
        border: 0;
        transform: scale(1.1);
    }

    .github-corner svg {
        color: #0f9d58;
        fill: #fff;
        height: 64px;
        width: 64px;
    }

    .github-corner:hover .octo-arm {
        animation: a 0.56s ease-in-out;
    }

    .github-corner .octo-arm {
        animation: none;
    }

    @keyframes a {
        0%,
        to {
            transform: rotate(0);
        }
        20%,
        60% {
            transform: rotate(-25deg);
        }
        40%,
        80% {
            transform: rotate(10deg);
        }
    }
</style>

<a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="github-corner tooltipped hide-on-med-and-down" target="_blank"
   data-tooltip="Fork Me" data-position="left" data-delay="50">
    <svg viewBox="0 0 250 250" aria-hidden="true">
        <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
        <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2"
              fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
        <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z"
              fill="currentColor" class="octo-body"></path>
    </svg>
</a>
        
    </nav>

</header>

    



<div class="bg-cover pd-header post-cover" style="background-image: url('/medias/featureimages/1.jpg')">
    <div class="container" style="right: 0px;left: 0px;">
        <div class="row">
            <div class="col s12 m12 l12">
                <div class="brand">
                    <h1 class="description center-align post-title">Java知识点（JVM篇）</h1>
                </div>
            </div>
        </div>
    </div>
</div>




<main class="post-container content">

    
    <link rel="stylesheet" href="/libs/tocbot/tocbot.css">
<style>
    #articleContent h1::before,
    #articleContent h2::before,
    #articleContent h3::before,
    #articleContent h4::before,
    #articleContent h5::before,
    #articleContent h6::before {
        display: block;
        content: " ";
        height: 100px;
        margin-top: -100px;
        visibility: hidden;
    }

    #articleContent :focus {
        outline: none;
    }

    .toc-fixed {
        position: fixed;
        top: 64px;
    }

    .toc-widget {
        width: 345px;
        padding-left: 20px;
    }

    .toc-widget .toc-title {
        padding: 35px 0 15px 17px;
        font-size: 1.5rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    .toc-widget ol {
        padding: 0;
        list-style: none;
    }

    #toc-content {
        padding-bottom: 30px;
        overflow: auto;
    }

    #toc-content ol {
        padding-left: 10px;
    }

    #toc-content ol li {
        padding-left: 10px;
    }

    #toc-content .toc-link:hover {
        color: #42b983;
        font-weight: 700;
        text-decoration: underline;
    }

    #toc-content .toc-link::before {
        background-color: transparent;
        max-height: 25px;

        position: absolute;
        right: 23.5vw;
        display: block;
    }

    #toc-content .is-active-link {
        color: #42b983;
    }

    #floating-toc-btn {
        position: fixed;
        right: 15px;
        bottom: 76px;
        padding-top: 15px;
        margin-bottom: 0;
        z-index: 998;
    }

    #floating-toc-btn .btn-floating {
        width: 48px;
        height: 48px;
    }

    #floating-toc-btn .btn-floating i {
        line-height: 48px;
        font-size: 1.4rem;
    }
</style>
<div class="row">
    <div id="main-content" class="col s12 m12 l9">
        <!-- 文章内容详情 -->
<div id="artDetail">
    <div class="card">
        <div class="card-content article-info">
            <div class="row tag-cate">
                <div class="col s7">
                    
                    <div class="article-tag">
                        
                            <a href="/tags/Java/">
                                <span class="chip bg-color">Java</span>
                            </a>
                        
                            <a href="/tags/%E6%95%99%E7%A8%8B/">
                                <span class="chip bg-color">教程</span>
                            </a>
                        
                            <a href="/tags/%E5%9F%BA%E7%A1%80/">
                                <span class="chip bg-color">基础</span>
                            </a>
                        
                    </div>
                    
                </div>
                <div class="col s5 right-align">
                    
                    <div class="post-cate">
                        <i class="fas fa-bookmark fa-fw icon-category"></i>
                        
                            <a href="/categories/Java%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/" class="post-category">
                                Java基础教程
                            </a>
                        
                    </div>
                    
                </div>
            </div>

            <div class="post-info">
                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-minus fa-fw"></i>发布日期:&nbsp;&nbsp;
                    2023-01-31
                </div>
                

                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-check fa-fw"></i>更新日期:&nbsp;&nbsp;
                    2023-01-31
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-file-word fa-fw"></i>文章字数:&nbsp;&nbsp;
                    11.1k
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-clock fa-fw"></i>阅读时长:&nbsp;&nbsp;
                    39 分
                </div>
                

                
                    <div id="busuanzi_container_page_pv" class="info-break-policy">
                        <i class="far fa-eye fa-fw"></i>阅读次数:&nbsp;&nbsp;
                        <span id="busuanzi_value_page_pv"></span>
                    </div>
				
            </div>
        </div>
        <hr class="clearfix">

        

        

        <div class="card-content article-card-content">
            <div id="articleContent">
                <h2 id="JVM篇"><a href="#JVM篇" class="headerlink" title="JVM篇"></a>JVM篇</h2><h3 id="1-、知识点汇总"><a href="#1-、知识点汇总" class="headerlink" title="1 、知识点汇总"></a>1 、知识点汇总</h3><p>JVM是Java运行基础,面试时一定会遇到JVM的有关问题,内容相对集中,但对只是深度要求较高.</p>
<h5 id="其中内存模型-类加载机制-GC是重点方面-性能调优部分更偏向应用-重点突出实践能力-编译器优化"><a href="#其中内存模型-类加载机制-GC是重点方面-性能调优部分更偏向应用-重点突出实践能力-编译器优化" class="headerlink" title="其中内存模型,类加载机制,GC是重点方面.性能调优部分更偏向应用,重点突出实践能力.编译器优化"></a>其中内存模型,类加载机制,GC是重点方面.性能调优部分更偏向应用,重点突出实践能力.编译器优化</h5><h5 id="和执行模式部分偏向于理论基础-重点掌握知识点"><a href="#和执行模式部分偏向于理论基础-重点掌握知识点" class="headerlink" title="和执行模式部分偏向于理论基础,重点掌握知识点."></a>和执行模式部分偏向于理论基础,重点掌握知识点.</h5><h5 id="需了解-内存模型各部分作用-保存哪些数据"><a href="#需了解-内存模型各部分作用-保存哪些数据" class="headerlink" title="需了解 内存模型各部分作用,保存哪些数据."></a>需了解 内存模型各部分作用,保存哪些数据.</h5><h5 id="类加载双亲委派加载机制-常用加载器分别加载哪种类型的类"><a href="#类加载双亲委派加载机制-常用加载器分别加载哪种类型的类" class="headerlink" title="类加载双亲委派加载机制,常用加载器分别加载哪种类型的类."></a>类加载双亲委派加载机制,常用加载器分别加载哪种类型的类.</h5><h5 id="GC分代回收的思想和依据以及不同垃圾回收算法的回收思路和适合场景"><a href="#GC分代回收的思想和依据以及不同垃圾回收算法的回收思路和适合场景" class="headerlink" title="GC分代回收的思想和依据以及不同垃圾回收算法的回收思路和适合场景."></a>GC分代回收的思想和依据以及不同垃圾回收算法的回收思路和适合场景.</h5><h5 id="性能调优常有JVM优化参数作用-参数调优的依据-常用的JVM分析工具能分析哪些问题以及使用方法"><a href="#性能调优常有JVM优化参数作用-参数调优的依据-常用的JVM分析工具能分析哪些问题以及使用方法" class="headerlink" title="性能调优常有JVM优化参数作用,参数调优的依据,常用的JVM分析工具能分析哪些问题以及使用方法."></a>性能调优常有JVM优化参数作用,参数调优的依据,常用的JVM分析工具能分析哪些问题以及使用方法.</h5><p>执行模式解释/编译/混合模式的优缺点,Java7提供的分层编译技术,JIT即时编译技术,OSR栈上替<br>换,C1/C2编译器针对的场景,C2针对的是server模式,优化更激进.新技术方面Java10的graal编译器</p>
<p>编译器优化javac的编译过程,ast抽象语法树,编译器优化和运行器优化.</p>
<h3 id="2-、知识点详解："><a href="#2-、知识点详解：" class="headerlink" title="2 、知识点详解："></a>2 、知识点详解：</h3><h5 id="1-、JVM内存模型："><a href="#1-、JVM内存模型：" class="headerlink" title="1 、JVM内存模型："></a>1 、JVM内存模型：</h5><h5 id="线程独占-栈-本地方法栈-程序计数器-线程共享-堆-方法区"><a href="#线程独占-栈-本地方法栈-程序计数器-线程共享-堆-方法区" class="headerlink" title="线程独占:栈,本地方法栈,程序计数器 线程共享:堆,方法区"></a>线程独占:栈,本地方法栈,程序计数器 线程共享:堆,方法区</h5><h5 id="2-、栈："><a href="#2-、栈：" class="headerlink" title="2 、栈："></a>2 、栈：</h5><h5 id="又称方法栈-线程私有的-线程执行方法是都会创建一个栈阵-用来存储局部变量表-操作栈-动态链接-方"><a href="#又称方法栈-线程私有的-线程执行方法是都会创建一个栈阵-用来存储局部变量表-操作栈-动态链接-方" class="headerlink" title="又称方法栈,线程私有的,线程执行方法是都会创建一个栈阵,用来存储局部变量表,操作栈,动态链接,方"></a>又称方法栈,线程私有的,线程执行方法是都会创建一个栈阵,用来存储局部变量表,操作栈,动态链接,方</h5><h5 id="法出口等信息-调用方法时执行入栈-方法返回式执行出栈"><a href="#法出口等信息-调用方法时执行入栈-方法返回式执行出栈" class="headerlink" title="法出口等信息.调用方法时执行入栈,方法返回式执行出栈."></a>法出口等信息.调用方法时执行入栈,方法返回式执行出栈.</h5><h5 id="3-、本地方法栈"><a href="#3-、本地方法栈" class="headerlink" title="3 、本地方法栈"></a>3 、本地方法栈</h5><p>与栈类似,也是用来保存执行方法的信息.执行Java方法是使用栈,执行Native方法时使用本地方法栈.</p>
<p>4 、程序计数器</p>
<p>保存着当前线程执行的字节码位置,每个线程工作时都有独立的计数器,只为执行Java方法服务,执行<br>Native方法时,程序计数器为空.</p>
<p>5 、堆</p>
<p>JVM内存管理最大的一块,对被线程共享,目的是存放对象的实例,几乎所欲的对象实例都会放在这里,<br>当堆没有可用空间时,会抛出OOM异常.根据对象的存活周期不同,JVM把对象进行分代管理,由垃圾回<br>收器进行垃圾的回收管理</p>
<p>6 、方法区：</p>
<p>又称非堆区,用于存储已被虚拟机加载的类信息,常量,静态变量,即时编译器优化后的代码等数据.1.7<br>的永久代和1.8的元空间都是方法区的一种实现</p>
<p>7 、JVM 内存可见性</p>
<h5 id="JMM是定义程序中变量的访问规则-线程对于变量的操作只能在自己的工作内存中进行-而不能直接对"><a href="#JMM是定义程序中变量的访问规则-线程对于变量的操作只能在自己的工作内存中进行-而不能直接对" class="headerlink" title="JMM是定义程序中变量的访问规则,线程对于变量的操作只能在自己的工作内存中进行,而不能直接对"></a>JMM是定义程序中变量的访问规则,线程对于变量的操作只能在自己的工作内存中进行,而不能直接对</h5><h5 id="主内存操作-由于指令重排序-读写的顺序会被打乱-因此JMM需要提供原子性-可见性-有序性保证"><a href="#主内存操作-由于指令重排序-读写的顺序会被打乱-因此JMM需要提供原子性-可见性-有序性保证" class="headerlink" title="主内存操作.由于指令重排序,读写的顺序会被打乱,因此JMM需要提供原子性,可见性,有序性保证."></a>主内存操作.由于指令重排序,读写的顺序会被打乱,因此JMM需要提供原子性,可见性,有序性保证.</h5><h3 id="3-、说说类加载与卸载"><a href="#3-、说说类加载与卸载" class="headerlink" title="3 、说说类加载与卸载"></a>3 、说说类加载与卸载</h3><h5 id="加载过程"><a href="#加载过程" class="headerlink" title="加载过程"></a>加载过程</h5><h5 id="其中验证-准备-解析合称链接"><a href="#其中验证-准备-解析合称链接" class="headerlink" title="其中验证,准备,解析合称链接"></a>其中验证,准备,解析合称链接</h5><p>加载通过类的完全限定名,查找此类字节码文件,利用字节码文件创建Class对象.</p>
<p>验证确保Class文件符合当前虚拟机的要求,不会危害到虚拟机自身安全.</p>
<p>准备进行内存分配,为static修饰的类变量分配内存,并设置初始值(0或null).不包含final修饰的静态变<br>量,因为final变量在编译时分配.</p>
<p>解析将常量池中的符号引用替换为直接引用的过程.直接引用为直接指向目标的指针或者相对偏移量<br>等.</p>
<p>初始化主要完成静态块执行以及静态变量的赋值.先初始化父类,再初始化当前类.只有对类主动使用<br>时才会初始化.</p>
<p>触发条件包括,创建类的实例时,访问类的静态方法或静态变量的时候,使用Class.forName反射类的时<br>候,或者某个子类初始化的时候.</p>
<p>Java自带的加载器加载的类,在虚拟机的生命周期中是不会被卸载的,只有用户自定义的加载器加载的<br>类才可以被卸.</p>
<h5 id="1-、加载机制-双亲委派模式"><a href="#1-、加载机制-双亲委派模式" class="headerlink" title="1 、加载机制-双亲委派模式"></a>1 、加载机制-双亲委派模式</h5><h5 id="双亲委派模式-即加载器加载类时先把请求委托给自己的父类加载器执行-直到顶层的启动类加载器"><a href="#双亲委派模式-即加载器加载类时先把请求委托给自己的父类加载器执行-直到顶层的启动类加载器" class="headerlink" title="双亲委派模式,即加载器加载类时先把请求委托给自己的父类加载器执行,直到顶层的启动类加载器."></a>双亲委派模式,即加载器加载类时先把请求委托给自己的父类加载器执行,直到顶层的启动类加载器.</h5><h5 id="父类加载器能够完成加载则成功返回-不能则子类加载器才自己尝试加载"><a href="#父类加载器能够完成加载则成功返回-不能则子类加载器才自己尝试加载" class="headerlink" title="父类加载器能够完成加载则成功返回,不能则子类加载器才自己尝试加载.*"></a>父类加载器能够完成加载则成功返回,不能则子类加载器才自己尝试加载.*</h5><h5 id="优点"><a href="#优点" class="headerlink" title="优点:"></a>优点:</h5><h5 id="1-避免类的重复加载"><a href="#1-避免类的重复加载" class="headerlink" title="1. 避免类的重复加载"></a>1. 避免类的重复加载</h5><pre><code>2. 避免Java的核心API被篡改
</code></pre>
<p>2 、分代回收</p>
<p>分代回收基于两个事实:大部分对象很快就不使用了,还有一部分不会立即无用,但也不会持续很长时<br>间.</p>
<h5 id="年轻代-gt-标记-复制-老年代-gt-标记-清除"><a href="#年轻代-gt-标记-复制-老年代-gt-标记-清除" class="headerlink" title="年轻代->标记-复制 老年代->标记-清除"></a>年轻代-&gt;标记-复制 老年代-&gt;标记-清除</h5><h5 id="3-、回收算法"><a href="#3-、回收算法" class="headerlink" title="3 、回收算法"></a>3 、回收算法</h5><p>a、G1算法</p>
<p>1.9后默认的垃圾回收算法,特点保持高回收率的同时减少停顿.采用每次只清理一部分,而不是清理全<br>部的增量式清理,以保证停顿时间不会过长</p>
<p>其取消了年轻代与老年代的物理划分,但仍属于分代收集器,算法将堆分为若干个逻辑区域(region),一<br>部分用作年轻代,一部分用作老年代,还有用来存储巨型对象的分区.</p>
<p>同CMS相同,会遍历所有对象,标记引用情况,清除对象后会对区域进行复制移动,以整合碎片空间.</p>
<p>年轻代回收: 并行复制采用复制算法,并行收集,会StopTheWorld.</p>
<p>老年代回收: 会对年轻代一并回收</p>
<p>初始标记完成堆root对象的标记,会StopTheWorld. 并发标记 GC线程和应用线程并发执行. 最终标记<br>完成三色标记周期,会StopTheWorld. 复制/清楚会优先对可回收空间加大的区域进行回收</p>
<p>b、ZGC算法</p>
<p>前面提供的高效垃圾回收算法,针对大堆内存设计,可以处理TB级别的堆,可以做到10ms以下的回收停<br>顿时间.</p>
<h5 id="着色指针"><a href="#着色指针" class="headerlink" title="着色指针"></a>着色指针</h5><h5 id="读屏障"><a href="#读屏障" class="headerlink" title="读屏障"></a>读屏障</h5><h5 id="并发处理"><a href="#并发处理" class="headerlink" title="并发处理"></a>并发处理</h5><pre><code>基于region
内存压缩(整理)
</code></pre>
<p>roots标记：标记root对象,会StopTheWorld. 并发标记：利用读屏障与应用线程一起运行标记,可能<br>会发生StopTheWorld. 清除会清理标记为不可用的对象. roots重定位：是对存活的对象进行移动,以<br>腾出大块内存空间,减少碎片产生.重定位最开始会StopTheWorld,却决于重定位集与对象总活动集的<br>比例. 并发重定位与并发标记类似.</p>
<h3 id="4-、简述一下JVM的内存模型"><a href="#4-、简述一下JVM的内存模型" class="headerlink" title="4 、简述一下JVM的内存模型"></a>4 、简述一下JVM的内存模型</h3><h5 id="1-JVM内存模型简介"><a href="#1-JVM内存模型简介" class="headerlink" title="1.JVM内存模型简介"></a>1.JVM内存模型简介</h5><h5 id="JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一"><a href="#JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一" class="headerlink" title="JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一"></a>JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一</h5><p>些区域的数据是线程性独立的，随着线程创建和销毁。jvm内存模型总体架构图如下：（摘自oracle<br>官方网站）</p>
<p>JVM在执行Java程序时，会把它管理的内存划分为若干个的区域，每个区域都有自己的用途和创建<br>销毁时间。如下图所示，可以分为两大部分，线程私有区和共享区。下图是根据自己理解画的一个<br>JVM内存模型架构图：</p>
<h5 id="JVM内存分为线程私有区和线程共享区"><a href="#JVM内存分为线程私有区和线程共享区" class="headerlink" title="JVM内存分为线程私有区和线程共享区"></a>JVM内存分为线程私有区和线程共享区</h5><h5 id="线程私有区"><a href="#线程私有区" class="headerlink" title="线程私有区"></a>线程私有区</h5><h5 id="1-、程序计数器"><a href="#1-、程序计数器" class="headerlink" title="1 、程序计数器"></a>1 、程序计数器</h5><h5 id="当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发"><a href="#当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发" class="headerlink" title="当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发"></a>当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发</h5><h5 id="生线程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行"><a href="#生线程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行" class="headerlink" title="生线程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行"></a>生线程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行</h5><p>的是JAVA方法，计数器记录正在执行的java字节码地址，如果执行的是native方法，则计数器为<br>空。</p>
<p>2 、虚拟机栈</p>
<p>线程私有的，与线程在同一时间创建。管理JAVA方法执行的内存模型。每个方法执行时都会创建一<br>个桢栈来存储方法的的变量表、操作数栈、动态链接方法、返回值、返回地址等信息。栈的大小决<br>定了方法调用的可达深度（递归多少层次，或嵌套调用多少层其他方法，-Xss参数可以设置虚拟机<br>栈大小）。栈的大小可以是固定的，或者是动态扩展的。如果请求的栈深度大于最大可用深度，则<br>抛出stackOverflowError；如果栈是可动态扩展的，但没有内存空间支持扩展，则抛出<br>OutofMemoryError。 使用jclasslib工具可以查看class类文件的结构。下图为栈帧结构图：</p>
<h5 id="3-、本地方法栈-1"><a href="#3-、本地方法栈-1" class="headerlink" title="3 、本地方法栈"></a>3 、本地方法栈</h5><p>与虚拟机栈作用相似。但它不是为Java方法服务的，而是本地方法（C语言）。由于规范对这块没有<br>强制要求，不同虚拟机实现方法不同。</p>
<p>线程共享区</p>
<p>1 、方法区</p>
<p>线程共享的，用于存放被虚拟机加载的类的元数据信息，如常量、静态变量和即时编译器编译后的<br>代码。若要分代，算是永久代（老年代），以前类大多“static”的，很少被卸载或收集，现回收废弃<br>常量和无用的类。其中运行时常量池存放编译生成的各种常量。（如果hotspot虚拟机确定一个类<br>的定义信息不会被使用，也会将其回收。回收的基本条件至少有：所有该类的实例被回收，而且装<br>载该类的ClassLoader被回收）</p>
<p>2 、堆</p>
<p>存放对象实例和数组，是垃圾回收的主要区域，分为新生代和老年代。刚创建的对象在新生代的<br>Eden区中，经过GC后进入新生代的S0区中，再经过GC进入新生代的S1区中， 15 次GC后仍存在就<br>进入老年代。这是按照一种回收机制进行划分的，不是固定的。若堆的空间不够实例分配，则<br>OutOfMemoryError。</p>
<pre><code>Young Generation 即图中的Eden + From Space（s0） + To Space(s1)
Eden 存放新生的对象
Survivor Space 有两个，存放每次垃圾回收后存活的对象(s0+s1)
Old Generation Tenured Generation 即图中的Old Space
主要存放应用程序中生命周期长的存活对象
</code></pre>
<h3 id="5-、说说堆和栈的区别"><a href="#5-、说说堆和栈的区别" class="headerlink" title="5 、说说堆和栈的区别"></a>5 、说说堆和栈的区别</h3><h5 id="栈是运行时单位，代表着逻辑，内含基本数据类型和堆中对象引用，所在区域连续，没有碎片；堆"><a href="#栈是运行时单位，代表着逻辑，内含基本数据类型和堆中对象引用，所在区域连续，没有碎片；堆" class="headerlink" title="栈是运行时单位，代表着逻辑，内含基本数据类型和堆中对象引用，所在区域连续，没有碎片；堆"></a>栈是运行时单位，代表着逻辑，内含基本数据类型和堆中对象引用，所在区域连续，没有碎片；堆</h5><h5 id="是存储单位，代表着数据，可被多个栈共享（包括成员中基本数据类型、引用和引用对象），所在"><a href="#是存储单位，代表着数据，可被多个栈共享（包括成员中基本数据类型、引用和引用对象），所在" class="headerlink" title="是存储单位，代表着数据，可被多个栈共享（包括成员中基本数据类型、引用和引用对象），所在"></a>是存储单位，代表着数据，可被多个栈共享（包括成员中基本数据类型、引用和引用对象），所在</h5><h5 id="区域不连续，会有碎片。"><a href="#区域不连续，会有碎片。" class="headerlink" title="区域不连续，会有碎片。"></a>区域不连续，会有碎片。</h5><h5 id="1-、功能不同"><a href="#1-、功能不同" class="headerlink" title="1 、功能不同"></a>1 、功能不同</h5><p>栈内存用来存储局部变量和方法调用，而堆内存用来存储Java中的对象。无论是成员变量，局部变<br>量，还是类变量，它们指向的对象都存储在堆内存中。</p>
<p>2 、共享性不同</p>
<p>栈内存是线程私有的。 堆内存是所有线程共有的。</p>
<p>3 、异常错误不同</p>
<p>如果栈内存或者堆内存不足都会抛出异常。 栈空间不足：java.lang.StackOverFlowError。 堆空间<br>不足：java.lang.OutOfMemoryError。</p>
<p>4 、空间大小</p>
<p>栈的空间大小远远小于堆的。</p>
<h3 id="6-、-什么时候会触发FullGC"><a href="#6-、-什么时候会触发FullGC" class="headerlink" title="6 、 什么时候会触发FullGC"></a>6 、 什么时候会触发FullGC</h3><p>除直接调用System.gc外，触发Full GC执行的情况有如下四种。 1. 旧生代空间不足 旧生代空间只有<br>在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不<br>足，则抛出如下错误： java.lang.OutOfMemoryError: Java heap space 为避免以上两种状况引起<br>的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不<br>要创建过大的对象及数组。</p>
<ol start="2">
<li><p>Permanet Generation空间满 PermanetGeneration中存放的为一些class的信息等，当系统中<br>要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采<br>用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信<br>息： java.lang.OutOfMemoryError: PermGen space 为避免Perm Gen占满造成Full GC现象，可<br>采用的方法为增大Perm Gen空间或转为使用CMS GC。</p>
</li>
<li><p>CMS GC时出现promotion failed和concurrent mode failure 对于采用CMS进行旧生代GC的<br>程序而言，尤其要注意GC日志中是否有promotion failed和concurrent mode failure两种状况，当<br>这两种状况出现时可能会触发Full GC。 promotionfailed是在进行Minor GC时，survivor space放<br>不下、对象只能放入旧生代，而此时旧生代也放不下造成的；concurrent mode failure是在执行<br>CMS GC的过程中同时有对象要放入旧生代，而此时旧生代空间不足造成的。 应对措施为：增大<br>survivorspace、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由<br>于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况，可通过设置-<br>XX:CMSMaxAbortablePrecleanTime=5（单位为ms）来避免。</p>
</li>
<li><p>统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间 这是一个较为复杂的触发<br>情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor<br>GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩<br>余空间，那么就直接触发Full GC。 例如程序第一次触发MinorGC后，有6MB的对象晋升到旧生<br>代，那么当下一次Minor GC发生时，首先检查旧生代的剩余空间是否大于6MB，如果小于6MB，<br>则执行Full GC。 当新生代采用PSGC时，方式稍有不同，PS GC是在Minor GC后也会检查，例如上<br>面的例子中第一次Minor GC后，PS GC会检查此时旧生代的剩余空间是否大于6MB，如小于，则触<br>发对旧生代的回收。 除了以上 4 种状况外，对于使用RMI来进行RPC或管理的Sun JDK应用而言，默<br>认情况下会一小时执行一次Full GC。可通过在启动时通过- java-<br>Dsun.rmi.dgc.client.gcInterval=3600000来设置Full GC执行的间隔时间或通过-XX:+<br>DisableExplicitGC来禁止RMI调用System.gc。</p>
</li>
</ol>
<h3 id="7-、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语"><a href="#7-、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语" class="headerlink" title="7 、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语"></a>7 、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语</h3><h3 id="言”？"><a href="#言”？" class="headerlink" title="言”？"></a>言”？</h3><p>Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字<br>节码文件。 Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独<br>重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特<br>性。</p>
<h3 id="8-、Java内存结构"><a href="#8-、Java内存结构" class="headerlink" title="8 、Java内存结构"></a>8 、Java内存结构</h3><p>方法区和对是所有线程共享的内存区域；而java栈、本地方法栈和程序员计数器是运行是线程私有<br>的内存区域。</p>
<pre><code>Java堆（Heap）,是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内
存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实
例都在这里分配内存。
方法区（Method Area）,方法区（Method Area）与Java堆一样，是各个线程共享的内存区
域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数
据。
程序计数器（Program Counter Register）,程序计数器（Program Counter Register）是一块
较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。
JVM栈（JVM Stacks）,与程序计数器一样，Java虚拟机栈（Java Virtual Machine Stacks）也是
线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方
法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态
</code></pre>
<h5 id="链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机"><a href="#链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机" class="headerlink" title="链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机"></a>链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机</h5><h5 id="栈中从入栈到出栈的过程。"><a href="#栈中从入栈到出栈的过程。" class="headerlink" title="栈中从入栈到出栈的过程。"></a>栈中从入栈到出栈的过程。</h5><pre><code>本地方法栈（Native Method Stacks）,本地方法栈（Native Method Stacks）与虚拟机栈所发
挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服
务，而本地方法栈则是为虚拟机使用到的Native方法服务。
</code></pre>
<h3 id="9-、说说对象分配规则"><a href="#9-、说说对象分配规则" class="headerlink" title="9 、说说对象分配规则"></a>9 、说说对象分配规则</h3><pre><code>对象优先分配在Eden区，如果Eden区没有足够的空间时，虚拟机执行一次Minor GC。
大对象直接进入老年代（大对象是指需要大量连续内存空间的对象）。这样做的目的是避免在
Eden区和两个Survivor区之间发生大量的内存拷贝（新生代采用复制算法收集内存）。
长期存活的对象进入老年代。虚拟机为每个对象定义了一个年龄计数器，如果对象经过了 1 次
Minor GC那么对象会进入Survivor区，之后每经过一次Minor GC那么对象的年龄加 1 ，知道达
到阀值对象进入老年区。
动态判断对象的年龄。如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的
一半，年龄大于或等于该年龄的对象可以直接进入老年代。
空间分配担保。每次进行Minor GC时，JVM会计算Survivor区移至老年区的对象的平均大小，
如果这个值大于老年区的剩余值大小则进行一次Full GC，如果小于检查
HandlePromotionFailure设置，如果true则只进行Monitor GC,如果false则进行Full GC。
</code></pre>
<h3 id="10-、描述一下JVM加载class文件的原理机制？"><a href="#10-、描述一下JVM加载class文件的原理机制？" class="headerlink" title="10 、描述一下JVM加载class文件的原理机制？"></a>10 、描述一下JVM加载class文件的原理机制？</h3><p>JVM中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java中的类加载器是一个重要<br>的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。 由于Java的跨平台性，经过编<br>译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，<br>JVM会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把类的.class文<br>件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的<br>Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接<br>阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用<br>替换为直接引用）三个步骤。最后JVM对类进行初始化，包括：1)如果类存在直接的父类并且这个<br>类还没有被初始化，那么就先初始化父类；2)如果类中存在初始化语句，就依次执行这些初始化语<br>句。 类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器<br>（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子<br>类）。从Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM更好的保证了<br>Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个<br>父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加<br>载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明：</p>
<pre><code>Bootstrap：一般用本地代码实现，负责加载JVM基础核心类库（rt.jar）；
Extension：从java.ext.dirs系统属性所指定的目录中加载类库，它的父加载器是Bootstrap；
</code></pre>
<pre><code>System：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变
量classpath或者系统属性java.class.path所指定的目录中记载类，是用户自定义加载器的默认
父加载器。
</code></pre>
<h3 id="11-、说说Java对象创建过程"><a href="#11-、说说Java对象创建过程" class="headerlink" title="11 、说说Java对象创建过程"></a>11 、说说Java对象创建过程</h3><h5 id="1-JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符"><a href="#1-JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符" class="headerlink" title="1.JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符"></a>1.JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符</h5><h5 id="号引用。然后加载这个类（类加载过程在后边讲）"><a href="#号引用。然后加载这个类（类加载过程在后边讲）" class="headerlink" title="号引用。然后加载这个类（类加载过程在后边讲）"></a>号引用。然后加载这个类（类加载过程在后边讲）</h5><h5 id="2-为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”，最终常用的办法“本地线程缓冲分"><a href="#2-为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”，最终常用的办法“本地线程缓冲分" class="headerlink" title="2.为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”，最终常用的办法“本地线程缓冲分"></a>2.为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”，最终常用的办法“本地线程缓冲分</h5><h5 id="配-TLAB-”"><a href="#配-TLAB-”" class="headerlink" title="配(TLAB)”"></a>配(TLAB)”</h5><h5 id="3-将除对象头外的对象内存空间初始化为-0"><a href="#3-将除对象头外的对象内存空间初始化为-0" class="headerlink" title="3.将除对象头外的对象内存空间初始化为 0"></a>3.将除对象头外的对象内存空间初始化为 0</h5><h5 id="4-对对象头进行必要设置"><a href="#4-对对象头进行必要设置" class="headerlink" title="4.对对象头进行必要设置"></a>4.对对象头进行必要设置</h5><h3 id="12-、知道类的生命周期吗？"><a href="#12-、知道类的生命周期吗？" class="headerlink" title="12 、知道类的生命周期吗？"></a>12 、知道类的生命周期吗？</h3><h5 id="类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程"><a href="#类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程" class="headerlink" title="类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程,"></a>类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程,</h5><h5 id="如下图；"><a href="#如下图；" class="headerlink" title="如下图；"></a>如下图；</h5><pre><code>加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象
连接，连接又包含三块内容：验证、准备、初始化。 1 ）验证，文件格式、元数据、字节码、
符号引用验证； 2 ）准备，为类的静态变量分配内存，并将其初始化为默认值； 3 ）解析，把
类中的符号引用转换为直接引用
初始化，为类的静态变量赋予正确的初始值
使用，new出对象程序中使用
卸载，执行垃圾回收
</code></pre>
<h3 id="13-、简述Java的对象结构"><a href="#13-、简述Java的对象结构" class="headerlink" title="13 、简述Java的对象结构"></a>13 、简述Java的对象结构</h3><p>Java对象由三个部分组成：对象头、实例数据、对齐填充。</p>
<h5 id="对象头由两部分组成，第一部分存储对象自身的运行时数据：哈希码、GC分代年龄、锁标识状态、"><a href="#对象头由两部分组成，第一部分存储对象自身的运行时数据：哈希码、GC分代年龄、锁标识状态、" class="headerlink" title="对象头由两部分组成，第一部分存储对象自身的运行时数据：哈希码、GC分代年龄、锁标识状态、"></a>对象头由两部分组成，第一部分存储对象自身的运行时数据：哈希码、GC分代年龄、锁标识状态、</h5><p>线程持有的锁、偏向线程ID（一般占32/64 bit）。第二部分是指针类型，指向对象的类元数据类型<br>（即对象代表哪个类）。如果是数组对象，则对象头中还有一部分用来记录数组长度。</p>
<p>实例数据用来存储对象真正的有效信息（包括父类继承下来的和自己定义的）</p>
<p>对齐填充：JVM要求对象起始地址必须是 8 字节的整数倍（ 8 字节对齐）</p>
<h3 id="14-、如何判断对象可以被回收？"><a href="#14-、如何判断对象可以被回收？" class="headerlink" title="14 、如何判断对象可以被回收？"></a>14 、如何判断对象可以被回收？</h3><h5 id="判断对象是否存活一般有两种方式："><a href="#判断对象是否存活一般有两种方式：" class="headerlink" title="判断对象是否存活一般有两种方式："></a>判断对象是否存活一般有两种方式：</h5><h5 id="引用计数：每个对象有一个引用计数属性，新增一个引用时计数加-1-，引用释放时计数减-1-，计"><a href="#引用计数：每个对象有一个引用计数属性，新增一个引用时计数加-1-，引用释放时计数减-1-，计" class="headerlink" title="引用计数：每个对象有一个引用计数属性，新增一个引用时计数加 1 ，引用释放时计数减 1 ，计"></a>引用计数：每个对象有一个引用计数属性，新增一个引用时计数加 1 ，引用释放时计数减 1 ，计</h5><h5 id="数为-0-时可以回收。此方法简单，无法解决对象相互循环引用的问题。"><a href="#数为-0-时可以回收。此方法简单，无法解决对象相互循环引用的问题。" class="headerlink" title="数为 0 时可以回收。此方法简单，无法解决对象相互循环引用的问题。"></a>数为 0 时可以回收。此方法简单，无法解决对象相互循环引用的问题。</h5><pre><code>可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引
用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的，不可达对
象。
</code></pre>
<h3 id="15-、JVM的永久代中会发生垃圾回收么？"><a href="#15-、JVM的永久代中会发生垃圾回收么？" class="headerlink" title="15 、JVM的永久代中会发生垃圾回收么？"></a>15 、JVM的永久代中会发生垃圾回收么？</h3><p>垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full<br>GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确<br>的永久代大小对避免Full GC是非常重要的原因。请参考下Java8：从永久代到元数据区 (注：Java8<br>中已经移除了永久代，新加了一个叫做元数据区的native内存区)</p>
<h3 id="16-、你知道哪些垃圾收集算法"><a href="#16-、你知道哪些垃圾收集算法" class="headerlink" title="16 、你知道哪些垃圾收集算法"></a>16 、你知道哪些垃圾收集算法</h3><h5 id="GC最基础的算法有三种：-标记-清除算法、复制算法、标记-压缩算法，我们常用的垃圾回收器一般"><a href="#GC最基础的算法有三种：-标记-清除算法、复制算法、标记-压缩算法，我们常用的垃圾回收器一般" class="headerlink" title="GC最基础的算法有三种： 标记 -清除算法、复制算法、标记-压缩算法，我们常用的垃圾回收器一般"></a>GC最基础的算法有三种： 标记 -清除算法、复制算法、标记-压缩算法，我们常用的垃圾回收器一般</h5><h5 id="都采用分代收集算法。"><a href="#都采用分代收集算法。" class="headerlink" title="都采用分代收集算法。"></a>都采用分代收集算法。</h5><pre><code>标记 -清除算法，“标记-清除”（Mark-Sweep）算法，如它的名字一样，算法分为“标记”和“清
除”两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。
复制算法，“复制”（Copying）的收集算法，它将可用内存按容量划分为大小相等的两块，每次
只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后
再把已使用过的内存空间一次清理掉。
标记-压缩算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行
清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存
分代收集算法，“分代收集”（Generational Collection）算法，把Java堆分为新生代和老年代，
这样就可以根据各个年代的特点采用最适当的收集算法。
</code></pre>
<h3 id="17-、调优命令有哪些？"><a href="#17-、调优命令有哪些？" class="headerlink" title="17 、调优命令有哪些？"></a>17 、调优命令有哪些？</h3><p>Sun JDK监控和故障处理命令有jps jstat jmap jhat jstack jinfo</p>
<pre><code>jps，JVM Process Status Tool,显示指定系统内所有的HotSpot虚拟机进程。
jstat，JVM statistics Monitoring是用于监视虚拟机运行时状态信息的命令，它可以显示出虚拟
机进程中的类装载、内存、垃圾收集、JIT编译等运行数据。
jmap，JVM Memory Map命令用于生成heap dump文件
jhat，JVM Heap Analysis Tool命令是与jmap搭配使用，用来分析jmap生成的dump，jhat内
置了一个微型的HTTP/HTML服务器，生成dump的分析结果后，可以在浏览器中查看
jstack，用于生成java虚拟机当前时刻的线程快照。
jinfo，JVM Configuration info 这个命令作用是实时查看和调整虚拟机运行参数。
</code></pre>
<h3 id="18-、常见调优工具有哪些"><a href="#18-、常见调优工具有哪些" class="headerlink" title="18 、常见调优工具有哪些"></a>18 、常见调优工具有哪些</h3><p>常用调优工具分为两类,jdk自带监控工具：jconsole和jvisualvm，第三方有：MAT(Memory<br>Analyzer Tool)、GChisto。</p>
<pre><code>jconsole，Java Monitoring and Management Console是从java5开始，在JDK中自带的java监
控和管理控制台，用于对JVM中内存，线程和类等的监控
jvisualvm，jdk自带全能工具，可以分析内存快照、线程快照；监控内存变化、GC变化等。
MAT，Memory Analyzer Tool，一个基于Eclipse的内存分析工具，是一个快速、功能丰富的
Java heap分析工具，它可以帮助我们查找内存泄漏和减少内存消耗
GChisto，一款专业分析gc日志的工具
</code></pre>
<h3 id="19-、Minor-GC与Full-GC分别在什么时候发生？"><a href="#19-、Minor-GC与Full-GC分别在什么时候发生？" class="headerlink" title="19 、Minor GC与Full GC分别在什么时候发生？"></a>19 、Minor GC与Full GC分别在什么时候发生？</h3><h5 id="新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC"><a href="#新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC" class="headerlink" title="新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC"></a>新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC</h5><h3 id="20-、你知道哪些JVM性能调优参数？（简单版回答）"><a href="#20-、你知道哪些JVM性能调优参数？（简单版回答）" class="headerlink" title="20 、你知道哪些JVM性能调优参数？（简单版回答）"></a>20 、你知道哪些JVM性能调优参数？（简单版回答）</h3><h5 id="设定堆内存大小"><a href="#设定堆内存大小" class="headerlink" title="设定堆内存大小"></a>设定堆内存大小</h5><p>-Xmx：堆内存最大限制。</p>
<pre><code>设定新生代大小。 新生代不宜太小，否则会有大量对象涌入老年代
</code></pre>
<p>-XX:NewSize：新生代大小</p>
<p>-XX:NewRatio 新生代和老生代占比</p>
<p>-XX:SurvivorRatio：伊甸园空间和幸存者空间的占比</p>
<pre><code>设定垃圾回收器 年轻代用 -XX:+UseParNewGC 年老代用-XX:+UseConcMarkSweepGC
</code></pre>
<h3 id="21-、-对象一定分配在堆中吗？有没有了解逃逸分析技术？"><a href="#21-、-对象一定分配在堆中吗？有没有了解逃逸分析技术？" class="headerlink" title="21 、 对象一定分配在堆中吗？有没有了解逃逸分析技术？"></a>21 、 对象一定分配在堆中吗？有没有了解逃逸分析技术？</h3><h5 id="「对象一定分配在堆中吗？」-不一定的，JVM通过「逃逸分析」，那些逃不出方法的对象会在栈上"><a href="#「对象一定分配在堆中吗？」-不一定的，JVM通过「逃逸分析」，那些逃不出方法的对象会在栈上" class="headerlink" title="「对象一定分配在堆中吗？」 不一定的，JVM通过「逃逸分析」，那些逃不出方法的对象会在栈上"></a>「对象一定分配在堆中吗？」 不一定的，JVM通过「逃逸分析」，那些逃不出方法的对象会在栈上</h5><h5 id="分配。"><a href="#分配。" class="headerlink" title="分配。"></a>分配。</h5><h5 id="「什么是逃逸分析？」"><a href="#「什么是逃逸分析？」" class="headerlink" title="「什么是逃逸分析？」"></a>「什么是逃逸分析？」</h5><p>逃逸分析(Escape Analysis)，是一种可以有效减少Java 程序中同步负载和内存堆分配压力的跨函数<br>全局数据流分析算法。通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用<br>范围，从而决定是否要将这个对象分配到堆上。</p>
<p>逃逸分析是指分析指针动态范围的方法，它同编译器优化原理的指针分析和外形分析相关联。当变<br>量（或者对象）在方法中分配后，其指针有可能被返回或者被全局引用，这样就会被其他方法或者<br>线程所引用，这种现象称作指针（或者引用）的逃逸(Escape)。通俗点讲，如果一个对象的指针被<br>多个方法或者线程引用时，那么我们就称这个对象的指针发生了逃逸。</p>
<p>「逃逸分析的好处」</p>
<pre><code>栈上分配，可以降低垃圾收集器运行的频率。
同步消除，如果发现某个对象只能从一个线程可访问，那么在这个对象上的操作可以不需要同
步。
标量替换，把对象分解成一个个基本类型，并且内存分配不再是分配在堆上，而是分配在栈
上。这样的好处有，一、减少内存使用，因为不用生成对象头。二、程序内存回收效率高，并
且GC频率也会减少。
</code></pre>
<h3 id="22-、虚拟机为什么使用元空间替换了永久代？"><a href="#22-、虚拟机为什么使用元空间替换了永久代？" class="headerlink" title="22 、虚拟机为什么使用元空间替换了永久代？"></a>22 、虚拟机为什么使用元空间替换了永久代？</h3><h5 id="「什么是元空间？什么是永久代？为什么用元空间代替永久代？」-我们先回顾一下「方法区」吧-看"><a href="#「什么是元空间？什么是永久代？为什么用元空间代替永久代？」-我们先回顾一下「方法区」吧-看" class="headerlink" title="「什么是元空间？什么是永久代？为什么用元空间代替永久代？」 我们先回顾一下「方法区」吧,看"></a>「什么是元空间？什么是永久代？为什么用元空间代替永久代？」 我们先回顾一下「方法区」吧,看</h5><h5 id="看虚拟机运行时数据内存图，如下"><a href="#看虚拟机运行时数据内存图，如下" class="headerlink" title="看虚拟机运行时数据内存图，如下:"></a>看虚拟机运行时数据内存图，如下:</h5><h5 id="方法区和堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、"><a href="#方法区和堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、" class="headerlink" title="方法区和堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、"></a>方法区和堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、</h5><h5 id="静态变量、即时编译后的代码等数据。"><a href="#静态变量、即时编译后的代码等数据。" class="headerlink" title="静态变量、即时编译后的代码等数据。"></a>静态变量、即时编译后的代码等数据。</h5><h5 id="「什么是永久代？它和方法区有什么关系呢？」"><a href="#「什么是永久代？它和方法区有什么关系呢？」" class="headerlink" title="「什么是永久代？它和方法区有什么关系呢？」"></a>「什么是永久代？它和方法区有什么关系呢？」</h5><pre><code>如果在HotSpot虚拟机上开发、部署，很多程序员都把方法区称作永久代。可以说方法区是规
范，永久代是Hotspot针对该规范进行的实现。在Java7及以前的版本，方法区都是永久代实现
的。
</code></pre>
<p>「什么是元空间？它和方法区有什么关系呢？」</p>
<pre><code>对于Java8，HotSpots取消了永久代，取而代之的是元空间(Metaspace)。换句话说，就是方
法区还是在的，只是实现变了，从永久代变为元空间了。
</code></pre>
<p>「为什么使用元空间替换了永久代？」</p>
<pre><code>永久代的方法区，和堆使用的物理内存是连续的。
</code></pre>
<h5 id="「永久代」是通过以下这两个参数配置大小的"><a href="#「永久代」是通过以下这两个参数配置大小的" class="headerlink" title="「永久代」是通过以下这两个参数配置大小的~"></a>「永久代」是通过以下这两个参数配置大小的~</h5><pre><code>-XX:PremSize：设置永久代的初始大小
-XX:MaxPermSize: 设置永久代的最大值，默认是64M
</code></pre>
<p>对于「永久代」，如果动态生成很多class的话，就很可能出现「java.lang.OutOfMemoryError:<br>PermGen space错误」，因为永久代空间配置有限嘛。最典型的场景是，在web开发比较多jsp页<br>面的时候。</p>
<pre><code>JDK8之后，方法区存在于元空间(Metaspace)。物理内存不再与堆连续，而是直接存在于本地
内存中，理论上机器「内存有多大，元空间就有多大」。
</code></pre>
<h5 id="可以通过以下的参数来设置元空间的大小："><a href="#可以通过以下的参数来设置元空间的大小：" class="headerlink" title="可以通过以下的参数来设置元空间的大小："></a>可以通过以下的参数来设置元空间的大小：</h5><pre><code>-XX:MetaspaceSize，初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC
会对该值进行调整：如果释放了大量的空间，就适当降低该值；如果释放了很少的空间，
那么在不超过MaxMetaspaceSize时，适当提高该值。
-XX:MaxMetaspaceSize，最大空间，默认是没有限制的。
-XX:MinMetaspaceFreeRatio，在GC之后，最小的Metaspace剩余空间容量的百分比，
减少为分配空间所导致的垃圾收集
-XX:MaxMetaspaceFreeRatio，在GC之后，最大的Metaspace剩余空间容量的百分比，
减少为释放空间所导致的垃圾收集
</code></pre>
<p>「所以，为什么使用元空间替换永久代？」</p>
<pre><code>表面上看是为了避免OOM异常。因为通常使用PermSize和MaxPermSize设置永久代的大小就
决定了永久代的上限，但是不是总能知道应该设置为多大合适, 如果使用默认值很容易遇到
OOM错误。当使用元空间时，可以加载多少类的元数据就不再由MaxPermSize控制, 而由系统
的实际可用空间来控制啦。
</code></pre>
<h3 id="23-、什么是Stop-The-World-什么是OopMap？什么是安全"><a href="#23-、什么是Stop-The-World-什么是OopMap？什么是安全" class="headerlink" title="23 、什么是Stop The World? 什么是OopMap？什么是安全"></a>23 、什么是Stop The World? 什么是OopMap？什么是安全</h3><h3 id="点？"><a href="#点？" class="headerlink" title="点？"></a>点？</h3><h5 id="进行垃圾回收的过程中，会涉及对象的移动。为了保证对象引用更新的正确性，必须暂停所有的用"><a href="#进行垃圾回收的过程中，会涉及对象的移动。为了保证对象引用更新的正确性，必须暂停所有的用" class="headerlink" title="进行垃圾回收的过程中，会涉及对象的移动。为了保证对象引用更新的正确性，必须暂停所有的用"></a>进行垃圾回收的过程中，会涉及对象的移动。为了保证对象引用更新的正确性，必须暂停所有的用</h5><p>户线程，像这样的停顿，虚拟机设计者形象描述为「Stop The World」。也简称为STW。</p>
<p>在HotSpot中，有个数据结构（映射表）称为「OopMap」。一旦类加载动作完成的时候，<br>HotSpot就会把对象内什么偏移量上是什么类型的数据计算出来，记录到OopMap。在即时编译过<br>程中，也会在「特定的位置」生成 OopMap，记录下栈上和寄存器里哪些位置是引用。</p>
<p>这些特定的位置主要在：</p>
<pre><code>1.循环的末尾（非 counted 循环）
2.方法临返回前 / 调用方法的call指令后
3.可能抛异常的位置
</code></pre>
<p>这些位置就叫作「安全点(safepoint)。」 用户程序执行时并非在代码指令流的任意位置都能够在<br>停顿下来开始垃圾收集，而是必须是执行到安全点才能够暂停。</p>
<h3 id="24-、说一下JVM-的主要组成部分及其作用？"><a href="#24-、说一下JVM-的主要组成部分及其作用？" class="headerlink" title="24 、说一下JVM 的主要组成部分及其作用？"></a>24 、说一下JVM 的主要组成部分及其作用？</h3><h5 id="JVM包含两个子系统和两个组件，分别为"><a href="#JVM包含两个子系统和两个组件，分别为" class="headerlink" title="JVM包含两个子系统和两个组件，分别为"></a>JVM包含两个子系统和两个组件，分别为</h5><pre><code>Class loader(类装载子系统)
Execution engine(执行引擎子系统)；
Runtime data area(运行时数据区组件)
Native Interface(本地接口组件)。
「Class loader(类装载)：」 根据给定的全限定名类名(如：java.lang.Object)来装载class文件
到运行时数据区的方法区中。
</code></pre>
<pre><code>「Execution engine（执行引擎）」：执行class的指令。
「Native Interface(本地接口)：」 与native lib交互，是其它编程语言交互的接口。
「Runtime data area(运行时数据区域)」：即我们常说的JVM的内存。
首先通过编译器把 Java源代码转换成字节码，Class loader(类装载)再把字节码加载到内存
中，将其放在运行时数据区的方法区内，而字节码文件只是 JVM 的一套指令集规范，并不能直
接交给底层操作系统去执行，因此需要特定的命令解析器执行引擎（Execution Engine），将
字节码翻译成底层系统指令，再交由 CPU 去执行，而这个过程中需要调用其他语言的本地库
接口（Native Interface）来实现整个程序的功能。
</code></pre>
<h3 id="25-、什么是指针碰撞？"><a href="#25-、什么是指针碰撞？" class="headerlink" title="25 、什么是指针碰撞？"></a>25 、什么是指针碰撞？</h3><p>一般情况下，JVM的对象都放在堆内存中（发生逃逸分析除外）。当类加载检查通过后，Java虚拟<br>机开始为新生对象分配内存。如果Java堆中内存是绝对规整的，所有被使用过的的内存都被放到一<br>边，空闲的内存放到另外一边，中间放着一个指针作为分界点的指示器，所分配内存仅仅是把那个<br>指针向空闲空间方向挪动一段与对象大小相等的实例，这种分配方式就是 指针碰撞。</p>
<h3 id="26-，什么是空闲列表？"><a href="#26-，什么是空闲列表？" class="headerlink" title="26 ，什么是空闲列表？"></a>26 ，什么是空闲列表？</h3><p>如果Java堆内存中的内存并不是规整的，已被使用的内存和空闲的内存相互交错在一起，不可以进<br>行指针碰撞啦，虚拟机必须维护一个列表，记录哪些内存是可用的，在分配的时候从列表找到一块<br>大的空间分配给对象实例，并更新列表上的记录，这种分配方式就是空闲列表。</p>
<h3 id="27-，什么是TLAB？"><a href="#27-，什么是TLAB？" class="headerlink" title="27 ，什么是TLAB？"></a>27 ，什么是TLAB？</h3><p>可以把内存分配的动作按照线程划分在不同的空间之中进行，每个线程在Java堆中预先分配一小块<br>内存,这就是TLAB（Thread Local Allocation Buffer，本地线程分配缓存） 。虚拟机通过-<br>XX:UseTLAB设定它的。</p>
<h3 id="28-、对象头具体都包含哪些内容？"><a href="#28-、对象头具体都包含哪些内容？" class="headerlink" title="28 、对象头具体都包含哪些内容？"></a>28 、对象头具体都包含哪些内容？</h3><p>在我们常用的Hotspot虚拟机中，对象在内存中布局实际包含 3 个部分：</p>
<pre><code>1. 对象头
</code></pre>
<h5 id="2-实例数据"><a href="#2-实例数据" class="headerlink" title="2. 实例数据"></a>2. 实例数据</h5><h5 id="3-对齐填充"><a href="#3-对齐填充" class="headerlink" title="3. 对齐填充"></a>3. 对齐填充</h5><p>而对象头包含两部分内容，Mark Word中的内容会随着锁标志位而发生变化，所以只说存储结构就<br>好了。</p>
<pre><code>1. 对象自身运行时所需的数据，也被称为Mark Word，也就是用于轻量级锁和偏向锁的关键点。
具体的内容包含对象的hashcode、分代年龄、轻量级锁指针、重量级锁指针、GC标记、偏向
锁线程ID、偏向锁时间戳。
2. 存储类型指针，也就是指向类的元数据的指针，通过这个指针才能确定对象是属于哪个类的实
例。
</code></pre>
<p>如果是数组的话，则还包含了数组的长度。</p>
<h3 id="29-、你知道哪些JVM调优参数？"><a href="#29-、你知道哪些JVM调优参数？" class="headerlink" title="29 、你知道哪些JVM调优参数？"></a>29 、你知道哪些JVM调优参数？</h3><h5 id="「堆栈内存相关」"><a href="#「堆栈内存相关」" class="headerlink" title="「堆栈内存相关」"></a>「堆栈内存相关」</h5><pre><code>-Xms 设置初始堆的大小
-Xmx 设置最大堆的大小
-Xmn 设置年轻代大小，相当于同时配置-XX:NewSize和-XX:MaxNewSize为一样的值
-Xss 每个线程的堆栈大小
-XX:NewSize 设置年轻代大小(for 1.3/1.4)
-XX:MaxNewSize 年轻代最大值(for 1.3/1.4)
-XX:NewRatio 年轻代与年老代的比值(除去持久代)
-XX:SurvivorRatio Eden区与Survivor区的的比值
-XX:PretenureSizeThreshold 当创建的对象超过指定大小时，直接把对象分配在老年代。
-XX:MaxTenuringThreshold设定对象在Survivor复制的最大年龄阈值，超过阈值转移到
老年代
</code></pre>
<h5 id="「垃圾收集器相关」"><a href="#「垃圾收集器相关」" class="headerlink" title="「垃圾收集器相关」"></a>「垃圾收集器相关」</h5><pre><code>-XX:+UseParallelGC：选择垃圾收集器为并行收集器。
-XX:ParallelGCThreads=20：配置并行收集器的线程数
-XX:+UseConcMarkSweepGC：设置年老代为并发收集。
-XX:CMSFullGCsBeforeCompaction=5 由于并发收集器不对内存空间进行压缩、整理，
所以运行一段时间以后会产生“碎片”，使得运行效率降低。此值设置运行 5 次GC以后对内
存空间进行压缩、整理。
-XX:+UseCMSCompactAtFullCollection：打开对年老代的压缩。可能会影响性能，但是
可以消除碎片
</code></pre>
<p>「辅助信息相关」</p>
<pre><code>-XX:+PrintGCDetails 打印GC详细信息
-XX:+HeapDumpOnOutOfMemoryError让JVM在发生内存溢出的时候自动生成内存快照,
排查问题用
-XX:+DisableExplicitGC禁止系统System.gc()，防止手动误触发FGC造成问题.
-XX:+PrintTLAB 查看TLAB空间的使用情况
</code></pre>
<h3 id="30-、说一下-JVM-有哪些垃圾回收器？"><a href="#30-、说一下-JVM-有哪些垃圾回收器？" class="headerlink" title="30 、说一下 JVM 有哪些垃圾回收器？"></a>30 、说一下 JVM 有哪些垃圾回收器？</h3><h5 id="如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下图展示了"><a href="#如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下图展示了" class="headerlink" title="如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下图展示了"></a>如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下图展示了</h5><p>7 种作用于不同分代的收集器，其中用于回收新生代的收集器包括Serial、PraNew、Parallel<br>Scavenge，回收老年代的收集器包括Serial Old、Parallel Old、CMS，还有用于回收整个Java堆的<br>G1收集器。不同收集器之间的连线表示它们可以搭配使用。</p>
<pre><code>Serial收集器（复制算法): 新生代单线程收集器，标记和清理都是单线程，优点是简单高效；
ParNew收集器 (复制算法): 新生代收并行集器，实际上是Serial收集器的多线程版本，在多核
CPU环境下有着比Serial更好的表现；
Parallel Scavenge收集器 (复制算法): 新生代并行收集器，追求高吞吐量，高效利用 CPU。吞
吐量 = 用户线程时间/(用户线程时间+GC线程时间)，高吞吐量可以高效率的利用CPU时间，尽
快完成程序的运算任务，适合后台应用等对交互相应要求不高的场景；
Serial Old收集器 (标记-整理算法): 老年代单线程收集器，Serial收集器的老年代版本；
Parallel Old收集器 (标记-整理算法)： 老年代并行收集器，吞吐量优先，Parallel Scavenge收
集器的老年代版本；
CMS(Concurrent Mark Sweep)收集器（标记-清除算法）： 老年代并行收集器，以获取最短回
收停顿时间为目标的收集器，具有高并发、低停顿的特点，追求最短GC回收停顿时间。
G1(Garbage First)收集器 (标记-整理算法)： Java堆并行收集器，G1收集器是JDK1.7提供的一
个新收集器，G1收集器基于“标记-整理”算法实现，也就是说不会产生内存碎片。此外，G1收
集器不同于之前的收集器的一个重要特点是：G1回收的范围是整个Java堆(包括新生代，老年
代)，而前六种收集器回收的范围仅限于新生代或老年代。
ZGC（Z Garbage Collector）是一款由Oracle公司研发的，以低延迟为首要目标的一款垃圾收
集器。它是基于动态Region内存布局，（暂时）不设年龄分代，使用了读屏障、染色指针和内
存多重映射等技术来实现可并发的标记-整理算法的收集器。在JDK 11新加入，还在实验阶
段，主要特点是：回收TB级内存（最大4T），停顿时间不超过10ms。优点：低停顿，高吞吐
量，ZGC收集过程中额外耗费的内存小。缺点：浮动垃圾
目前使用的非常少，真正普及还是需要写时间的。
</code></pre>
<p>新生代收集器：Serial、ParNew、Parallel Scavenge</p>
<p>老年代收集器：CMS、Serial Old、Parallel Old</p>
<p>整堆收集器：G1，ZGC(因为不涉年代不在图中)。</p>
<h3 id="31-、如何选择垃圾收集器？"><a href="#31-、如何选择垃圾收集器？" class="headerlink" title="31 、如何选择垃圾收集器？"></a>31 、如何选择垃圾收集器？</h3><h5 id="1-如果你的堆大小不是很大（比如-100MB），选择串行收集器一般是效率最高的。"><a href="#1-如果你的堆大小不是很大（比如-100MB），选择串行收集器一般是效率最高的。" class="headerlink" title="1. 如果你的堆大小不是很大（比如 100MB），选择串行收集器一般是效率最高的。"></a>1. 如果你的堆大小不是很大（比如 100MB），选择串行收集器一般是效率最高的。</h5><pre><code>参数：-XX:+UseSerialGC。
2. 如果你的应用运行在单核的机器上，或者你的虚拟机核数只有单核，选择串行收集器依然是合
适的，这时候启用一些并行收集器没有任何收益。
参数：-XX:+UseSerialGC。
3. 如果你的应用是“吞吐量”优先的，并且对较长时间的停顿没有什么特别的要求。选择并行收集
器是比较好的。
参数：-XX:+UseParallelGC。
</code></pre>
<h5 id="4-如果你的应用对响应时间要求较高，想要较少的停顿。甚至-1-秒的停顿都会引起大量的请求失"><a href="#4-如果你的应用对响应时间要求较高，想要较少的停顿。甚至-1-秒的停顿都会引起大量的请求失" class="headerlink" title="4. 如果你的应用对响应时间要求较高，想要较少的停顿。甚至 1 秒的停顿都会引起大量的请求失"></a>4. 如果你的应用对响应时间要求较高，想要较少的停顿。甚至 1 秒的停顿都会引起大量的请求失</h5><h5 id="败，那么选择G1、ZGC、CMS都是合理的。虽然这些收集器的-GC-停顿通常都比较短，但它"><a href="#败，那么选择G1、ZGC、CMS都是合理的。虽然这些收集器的-GC-停顿通常都比较短，但它" class="headerlink" title="败，那么选择G1、ZGC、CMS都是合理的。虽然这些收集器的 GC 停顿通常都比较短，但它"></a>败，那么选择G1、ZGC、CMS都是合理的。虽然这些收集器的 GC 停顿通常都比较短，但它</h5><h5 id="需要一些额外的资源去处理这些工作，通常吞吐量会低一些。"><a href="#需要一些额外的资源去处理这些工作，通常吞吐量会低一些。" class="headerlink" title="需要一些额外的资源去处理这些工作，通常吞吐量会低一些。"></a>需要一些额外的资源去处理这些工作，通常吞吐量会低一些。</h5><h5 id="参数："><a href="#参数：" class="headerlink" title="参数："></a>参数：</h5><ul>
<li>XX:+UseConcMarkSweepGC、</li>
<li>XX:+UseG1GC、</li>
<li>XX:+UseZGC 等。</li>
</ul>
<p>从上面这些出发点来看，我们平常的 Web 服务器，都是对响应性要求非常高的。选择性其实就集<br>中在 CMS、G1、ZGC上。而对于某些定时任务，使用并行收集器，是一个比较好的选择。</p>
<h3 id="32-、-什么是类加载器？"><a href="#32-、-什么是类加载器？" class="headerlink" title="32 、 什么是类加载器？"></a>32 、 什么是类加载器？</h3><p>类加载器是一个用来加载类文件的类。Java 源代码通过 javac 编译器编译成类 文件。然后 JVM 来执<br>行类文件中的字节码来执行程序。类加载器负责加载文件 系统、网络或其他来源的类文件。</p>
<h3 id="33-、什么是-tomcat-类加载机制？"><a href="#33-、什么是-tomcat-类加载机制？" class="headerlink" title="33 、什么是 tomcat 类加载机制？"></a>33 、什么是 tomcat 类加载机制？</h3><p>在 tomcat 中类的加载稍有不同，如下图：</p>
<p>当 tomcat启动时，会创建几种类加载器： Bootstrap 引导类加载器 加载 JVM启动所需的类，以及<br>标准扩展类（位于jre/lib/ext 下） System 系统类加载器 加载 tomcat 启动的类，比如<br>bootstrap.jar，通常在 catalina.bat 或者 catalina.sh中指定。位于CATALINA_HOME/bin下。</p>
<p>Common 通用类加载器</p>

                
            </div>
            <hr/>

            

    <div class="reprint" id="reprint-statement">
        
            <div class="reprint__author">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-user">
                        文章作者:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="/about" rel="external nofollow noreferrer">YangChao</a>
                </span>
            </div>
            <div class="reprint__type">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-link">
                        文章链接:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="https://monkey-chao.gitee.io/2023/01/31/java-zhi-shi-dian-jvm-pian/">https://monkey-chao.gitee.io/2023/01/31/java-zhi-shi-dian-jvm-pian/</a>
                </span>
            </div>
            <div class="reprint__notice">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-copyright">
                        版权声明:
                    </i>
                </span>
                <span class="reprint-info">
                    本博客所有文章除特別声明外，均采用
                    <a href="https://creativecommons.org/licenses/by/4.0/deed.zh" rel="external nofollow noreferrer" target="_blank">CC BY 4.0</a>
                    许可协议。转载请注明来源
                    <a href="/about" target="_blank">YangChao</a>
                    !
                </span>
            </div>
        
    </div>

    <script async defer>
      document.addEventListener("copy", function (e) {
        let toastHTML = '<span>复制成功，请遵循本文的转载规则</span><button class="btn-flat toast-action" onclick="navToReprintStatement()" style="font-size: smaller">查看</a>';
        M.toast({html: toastHTML})
      });

      function navToReprintStatement() {
        $("html, body").animate({scrollTop: $("#reprint-statement").offset().top - 80}, 800);
      }
    </script>



            <div class="tag_share" style="display: block;">
                <div class="post-meta__tag-list" style="display: inline-block;">
                    
                        <div class="article-tag">
                            
                                <a href="/tags/Java/">
                                    <span class="chip bg-color">Java</span>
                                </a>
                            
                                <a href="/tags/%E6%95%99%E7%A8%8B/">
                                    <span class="chip bg-color">教程</span>
                                </a>
                            
                                <a href="/tags/%E5%9F%BA%E7%A1%80/">
                                    <span class="chip bg-color">基础</span>
                                </a>
                            
                        </div>
                    
                </div>
                <div class="post_share" style="zoom: 80%; width: fit-content; display: inline-block; float: right; margin: -0.15rem 0;">
                    <link rel="stylesheet" type="text/css" href="/libs/share/css/share.min.css">
<div id="article-share">

    
    <div class="social-share" data-sites="twitter,facebook,google,qq,qzone,wechat,weibo,douban,linkedin" data-wechat-qrcode-helper="<p>微信扫一扫即可分享！</p>"></div>
    <script src="/libs/share/js/social-share.min.js"></script>
    

    

</div>

                </div>
            </div>
            
                <style>
    #reward {
        margin: 40px 0;
        text-align: center;
    }

    #reward .reward-link {
        font-size: 1.4rem;
        line-height: 38px;
    }

    #reward .btn-floating:hover {
        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2), 0 5px 15px rgba(0, 0, 0, 0.2);
    }

    #rewardModal {
        width: 320px;
        height: 350px;
    }

    #rewardModal .reward-title {
        margin: 15px auto;
        padding-bottom: 5px;
    }

    #rewardModal .modal-content {
        padding: 10px;
    }

    #rewardModal .close {
        position: absolute;
        right: 15px;
        top: 15px;
        color: rgba(0, 0, 0, 0.5);
        font-size: 1.3rem;
        line-height: 20px;
        cursor: pointer;
    }

    #rewardModal .close:hover {
        color: #ef5350;
        transform: scale(1.3);
        -moz-transform:scale(1.3);
        -webkit-transform:scale(1.3);
        -o-transform:scale(1.3);
    }

    #rewardModal .reward-tabs {
        margin: 0 auto;
        width: 210px;
    }

    .reward-tabs .tabs {
        height: 38px;
        margin: 10px auto;
        padding-left: 0;
    }

    .reward-content ul {
        padding-left: 0 !important;
    }

    .reward-tabs .tabs .tab {
        height: 38px;
        line-height: 38px;
    }

    .reward-tabs .tab a {
        color: #fff;
        background-color: #ccc;
    }

    .reward-tabs .tab a:hover {
        background-color: #ccc;
        color: #fff;
    }

    .reward-tabs .wechat-tab .active {
        color: #fff !important;
        background-color: #22AB38 !important;
    }

    .reward-tabs .alipay-tab .active {
        color: #fff !important;
        background-color: #019FE8 !important;
    }

    .reward-tabs .reward-img {
        width: 210px;
        height: 210px;
    }
</style>

<div id="reward">
    <a href="#rewardModal" class="reward-link modal-trigger btn-floating btn-medium waves-effect waves-light red">赏</a>

    <!-- Modal Structure -->
    <div id="rewardModal" class="modal">
        <div class="modal-content">
            <a class="close modal-close"><i class="fas fa-times"></i></a>
            <h4 class="reward-title">你的赏识是我前进的动力</h4>
            <div class="reward-content">
                <div class="reward-tabs">
                    <ul class="tabs row">
                        <li class="tab col s6 alipay-tab waves-effect waves-light"><a href="#alipay">支付宝</a></li>
                        <li class="tab col s6 wechat-tab waves-effect waves-light"><a href="#wechat">微 信</a></li>
                    </ul>
                    <div id="alipay">
                        <img src="/medias/reward/alipay.jpg" class="reward-img" alt="支付宝打赏二维码">
                    </div>
                    <div id="wechat">
                        <img src="/medias/reward/wechat.png" class="reward-img" alt="微信打赏二维码">
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

<script>
    $(function () {
        $('.tabs').tabs();
    });
</script>

            
        </div>
    </div>

    

    

    

    
    <div class="livere-card card" data-aos="fade-up">
    <!-- 来必力City版安装代码 -->
    <div id="lv-container" class="card-content" data-id="city" data-uid="">
        <script type="text/javascript">
            (function (d, s) {
                let j, e = d.getElementsByTagName(s)[0];
                if (typeof LivereTower === 'function') {
                    return;
                }

                j = d.createElement(s);
                j.src = 'https://cdn-city.livere.com/js/embed.dist.js';
                j.async = true;

                e.parentNode.insertBefore(j, e);
            })(document, 'script');
        </script>
        <noscript>为正常使用来必力评论功能请激活JavaScript。</noscript>
    </div>
    <!-- City版安装代码已完成 -->
</div>
    

    
        <style>
    .valine-card {
        margin: 1.5rem auto;
    }

    .valine-card .card-content {
        padding: 20px 20px 5px 20px;
    }

    #vcomments textarea {
        box-sizing: border-box;
        background: url("/medias/comment_bg.png") 100% 100% no-repeat;
    }

    #vcomments p {
        margin: 2px 2px 10px;
        font-size: 1.05rem;
        line-height: 1.78rem;
    }

    #vcomments blockquote p {
        text-indent: 0.2rem;
    }

    #vcomments a {
        padding: 0 2px;
        color: #4cbf30;
        font-weight: 500;
        text-decoration: none;
    }

    #vcomments img {
        max-width: 100%;
        height: auto;
        cursor: pointer;
    }

    #vcomments ol li {
        list-style-type: decimal;
    }

    #vcomments ol,
    ul {
        display: block;
        padding-left: 2em;
        word-spacing: 0.05rem;
    }

    #vcomments ul li,
    ol li {
        display: list-item;
        line-height: 1.8rem;
        font-size: 1rem;
    }

    #vcomments ul li {
        list-style-type: disc;
    }

    #vcomments ul ul li {
        list-style-type: circle;
    }

    #vcomments table, th, td {
        padding: 12px 13px;
        border: 1px solid #dfe2e5;
    }

    #vcomments table, th, td {
        border: 0;
    }

    table tr:nth-child(2n), thead {
        background-color: #fafafa;
    }

    #vcomments table th {
        background-color: #f2f2f2;
        min-width: 80px;
    }

    #vcomments table td {
        min-width: 80px;
    }

    #vcomments h1 {
        font-size: 1.85rem;
        font-weight: bold;
        line-height: 2.2rem;
    }

    #vcomments h2 {
        font-size: 1.65rem;
        font-weight: bold;
        line-height: 1.9rem;
    }

    #vcomments h3 {
        font-size: 1.45rem;
        font-weight: bold;
        line-height: 1.7rem;
    }

    #vcomments h4 {
        font-size: 1.25rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    #vcomments h5 {
        font-size: 1.1rem;
        font-weight: bold;
        line-height: 1.4rem;
    }

    #vcomments h6 {
        font-size: 1rem;
        line-height: 1.3rem;
    }

    #vcomments p {
        font-size: 1rem;
        line-height: 1.5rem;
    }

    #vcomments hr {
        margin: 12px 0;
        border: 0;
        border-top: 1px solid #ccc;
    }

    #vcomments blockquote {
        margin: 15px 0;
        border-left: 5px solid #42b983;
        padding: 1rem 0.8rem 0.3rem 0.8rem;
        color: #666;
        background-color: rgba(66, 185, 131, .1);
    }

    #vcomments pre {
        font-family: monospace, monospace;
        padding: 1.2em;
        margin: .5em 0;
        background: #272822;
        overflow: auto;
        border-radius: 0.3em;
        tab-size: 4;
    }

    #vcomments code {
        font-family: monospace, monospace;
        padding: 1px 3px;
        font-size: 0.92rem;
        color: #e96900;
        background-color: #f8f8f8;
        border-radius: 2px;
    }

    #vcomments pre code {
        font-family: monospace, monospace;
        padding: 0;
        color: #e8eaf6;
        background-color: #272822;
    }

    #vcomments pre[class*="language-"] {
        padding: 1.2em;
        margin: .5em 0;
    }

    #vcomments code[class*="language-"],
    pre[class*="language-"] {
        color: #e8eaf6;
    }

    #vcomments [type="checkbox"]:not(:checked), [type="checkbox"]:checked {
        position: inherit;
        margin-left: -1.3rem;
        margin-right: 0.4rem;
        margin-top: -1px;
        vertical-align: middle;
        left: unset;
        visibility: visible;
    }

    #vcomments b,
    strong {
        font-weight: bold;
    }

    #vcomments dfn {
        font-style: italic;
    }

    #vcomments small {
        font-size: 85%;
    }

    #vcomments cite {
        font-style: normal;
    }

    #vcomments mark {
        background-color: #fcf8e3;
        padding: .2em;
    }

    #vcomments table, th, td {
        padding: 12px 13px;
        border: 1px solid #dfe2e5;
    }

    table tr:nth-child(2n), thead {
        background-color: #fafafa;
    }

    #vcomments table th {
        background-color: #f2f2f2;
        min-width: 80px;
    }

    #vcomments table td {
        min-width: 80px;
    }

    #vcomments [type="checkbox"]:not(:checked), [type="checkbox"]:checked {
        position: inherit;
        margin-left: -1.3rem;
        margin-right: 0.4rem;
        margin-top: -1px;
        vertical-align: middle;
        left: unset;
        visibility: visible;
    }
</style>

<div class="card valine-card" data-aos="fade-up">
    <div class="comment_headling" style="font-size: 20px; font-weight: 700; position: relative; padding-left: 20px; top: 15px; padding-bottom: 5px;">
        <i class="fas fa-comments fa-fw" aria-hidden="true"></i>
        <span>评论</span>
    </div>
    <div id="vcomments" class="card-content" style="display: grid">
    </div>
</div>

<script src="/libs/valine/av-min.js"></script>
<script src="/libs/valine/Valine.min.js"></script>
<script>
    new Valine({
        el: '#vcomments',
        appId: '1543373971',
        appKey: '111111',
        notify: 'false' === 'true',
        verify: 'false' === 'true',
        visitor: 'true' === 'true',
        avatar: 'mm',
        pageSize: '10',
        lang: 'zh-cn',
        placeholder: 'just go go'
    });
</script>

<!--酷Q推送-->


    

    
        <style>
    .mvaline-card {
        margin: 1.5rem auto;
    }

    .mvaline-card .card-content {
        padding: 20px 20px 5px 20px;
    }
</style>

<div class="card mvaline-card" data-aos="fade-up">
    <div class="comment_headling" style="font-size: 20px; font-weight: 700; position: relative; padding-left: 20px; top: 15px; padding-bottom: 5px;">
        <i class="fas fa-comments fa-fw" aria-hidden="true"></i>
        <span>评论</span>
    </div>
    <div id="mvcomments" class="card-content" style="display: grid">
    </div>
</div>

<script src="/libs/minivaline/MiniValine.js"></script>
<script>
    new MiniValine(Object.assign({"enable":true,"serverURL":"https://minivaline.your-domain.top"}, {
	  el: '#mvcomments',
    }));
</script>

    

    

    

    

    

<article id="prenext-posts" class="prev-next articles">
    <div class="row article-row">
        
        <div class="article col s12 m6" data-aos="fade-up" data-aos="fade-up">
            <div class="article-badge left-badge text-color">
                <i class="far fa-dot-circle"></i>&nbsp;本篇
            </div>
            <div class="card">
                <a href="/2023/01/31/java-zhi-shi-dian-jvm-pian/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/1.jpg" class="responsive-img" alt="Java知识点（JVM篇）">
                        
                        <span class="card-title">Java知识点（JVM篇）</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            JavaJVM篇
                        
                    </div>
                    <div class="publish-info">
                            <span class="publish-date">
                                <i class="far fa-clock fa-fw icon-date"></i>2023-01-31
                            </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/Java%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/" class="post-category">
                                    Java基础教程
                                </a>
                            
                            
                        </span>
                    </div>
                </div>

                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Java/">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                    <a href="/tags/%E6%95%99%E7%A8%8B/">
                        <span class="chip bg-color">教程</span>
                    </a>
                    
                    <a href="/tags/%E5%9F%BA%E7%A1%80/">
                        <span class="chip bg-color">基础</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge right-badge text-color">
                下一篇&nbsp;<i class="fas fa-chevron-right"></i>
            </div>
            <div class="card">
                <a href="/2023/01/31/java-zhi-shi-dian-ji-chu-pian/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/10.jpg" class="responsive-img" alt="Java知识点（基础篇）">
                        
                        <span class="card-title">Java知识点（基础篇）</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            Java基础入门篇
                        
                    </div>
                    <div class="publish-info">
                            <span class="publish-date">
                                <i class="far fa-clock fa-fw icon-date"></i>2023-01-31
                            </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/Java%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/" class="post-category">
                                    Java基础教程
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Java/">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                    <a href="/tags/%E6%95%99%E7%A8%8B/">
                        <span class="chip bg-color">教程</span>
                    </a>
                    
                    <a href="/tags/%E5%9F%BA%E7%A1%80/">
                        <span class="chip bg-color">基础</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
    </div>
</article>

</div>


<script>
    $('#articleContent').on('copy', function (e) {
        // IE8 or earlier browser is 'undefined'
        if (typeof window.getSelection === 'undefined') return;

        var selection = window.getSelection();
        // if the selection is short let's not annoy our users.
        if (('' + selection).length < Number.parseInt('120')) {
            return;
        }

        // create a div outside of the visible area and fill it with the selected text.
        var bodyElement = document.getElementsByTagName('body')[0];
        var newdiv = document.createElement('div');
        newdiv.style.position = 'absolute';
        newdiv.style.left = '-99999px';
        bodyElement.appendChild(newdiv);
        newdiv.appendChild(selection.getRangeAt(0).cloneContents());

        // we need a <pre> tag workaround.
        // otherwise the text inside "pre" loses all the line breaks!
        if (selection.getRangeAt(0).commonAncestorContainer.nodeName === 'PRE' || selection.getRangeAt(0).commonAncestorContainer.nodeName === 'CODE') {
            newdiv.innerHTML = "<pre>" + newdiv.innerHTML + "</pre>";
        }

        var url = document.location.href;
        newdiv.innerHTML += '<br />'
            + '来源: Angus<br />'
            + '文章作者: YangChao<br />'
            + '文章链接: <a href="' + url + '">' + url + '</a><br />'
            + '本文章著作权归作者所有，任何形式的转载都请注明出处。';

        selection.selectAllChildren(newdiv);
        window.setTimeout(function () {bodyElement.removeChild(newdiv);}, 200);
    });
</script>


<!-- 代码块功能依赖 -->
<script type="text/javascript" src="/libs/codeBlock/codeBlockFuction.js"></script>

<!-- 代码语言 -->

<script type="text/javascript" src="/libs/codeBlock/codeLang.js"></script>


<!-- 代码块复制 -->

<script type="text/javascript" src="/libs/codeBlock/codeCopy.js"></script>


<!-- 代码块收缩 -->

<script type="text/javascript" src="/libs/codeBlock/codeShrink.js"></script>


    </div>
    <div id="toc-aside" class="expanded col l3 hide-on-med-and-down">
        <div class="toc-widget card" style="background-color: white;">
            <div class="toc-title"><i class="far fa-list-alt"></i>&nbsp;&nbsp;目录</div>
            <div id="toc-content"></div>
        </div>
    </div>
</div>

<!-- TOC 悬浮按钮. -->

<div id="floating-toc-btn" class="hide-on-med-and-down">
    <a class="btn-floating btn-large bg-color">
        <i class="fas fa-list-ul"></i>
    </a>
</div>


<script src="/libs/tocbot/tocbot.min.js"></script>
<script>
    $(function () {
        tocbot.init({
            tocSelector: '#toc-content',
            contentSelector: '#articleContent',
            headingsOffset: -($(window).height() * 0.4 - 45),
            collapseDepth: Number('0'),
            headingSelector: 'h2, h3, h4'
        });

        // Set scroll toc fixed.
        let tocHeight = parseInt($(window).height() * 0.4 - 64);
        let $tocWidget = $('.toc-widget');
        $(window).scroll(function () {
            let scroll = $(window).scrollTop();
            /* add post toc fixed. */
            if (scroll > tocHeight) {
                $tocWidget.addClass('toc-fixed');
            } else {
                $tocWidget.removeClass('toc-fixed');
            }
        });

        
        /* 修复文章卡片 div 的宽度. */
        let fixPostCardWidth = function (srcId, targetId) {
            let srcDiv = $('#' + srcId);
            if (srcDiv.length === 0) {
                return;
            }

            let w = srcDiv.width();
            if (w >= 450) {
                w = w + 21;
            } else if (w >= 350 && w < 450) {
                w = w + 18;
            } else if (w >= 300 && w < 350) {
                w = w + 16;
            } else {
                w = w + 14;
            }
            $('#' + targetId).width(w);
        };

        // 切换TOC目录展开收缩的相关操作.
        const expandedClass = 'expanded';
        let $tocAside = $('#toc-aside');
        let $mainContent = $('#main-content');
        $('#floating-toc-btn .btn-floating').click(function () {
            if ($tocAside.hasClass(expandedClass)) {
                $tocAside.removeClass(expandedClass).hide();
                $mainContent.removeClass('l9');
            } else {
                $tocAside.addClass(expandedClass).show();
                $mainContent.addClass('l9');
            }
            fixPostCardWidth('artDetail', 'prenext-posts');
        });
        
    });
</script>

    

</main>




    <footer class="page-footer bg-color">
    

    <div class="container row center-align"
         style="margin-bottom: 0px !important;">
        <div class="col s12 m8 l8 copy-right">
            Copyright&nbsp;&copy;
            
                <span id="year">2019-2023</span>
            
            <a href="/about" target="_blank">YangChao</a>
<!--             |&nbsp;Powered by&nbsp;<a href="https://hexo.io/" target="_blank">Hexo</a>
            |&nbsp;Theme&nbsp;<a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" target="_blank">Matery</a> -->
            <br>
            
                &nbsp;<i class="fas fa-chart-area"></i>&nbsp;站点总字数:&nbsp;<span
                        class="white-color">460.9k</span>
            
            
            
                
            
            
                <span id="busuanzi_container_site_pv">
                &nbsp;|&nbsp;<i class="far fa-eye"></i>&nbsp;总访问量:&nbsp;
                    <span id="busuanzi_value_site_pv" class="white-color"></span>
            </span>
            
            
                <span id="busuanzi_container_site_uv">
                &nbsp;|&nbsp;<i class="fas fa-users"></i>&nbsp;总访问人数:&nbsp;
                    <span id="busuanzi_value_site_uv" class="white-color"></span>
            </span>
            
            <br>

            <!-- 运行天数提醒. -->
            
            <br>
            
        </div>
<!--         <div class="col s12 m4 l4 social-link social-statis">
    <a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="tooltipped" target="_blank" data-tooltip="访问我的GitHub" data-position="top" data-delay="50">
        <i class="fab fa-github"></i>
    </a>




<!-- 

 -->


    <a href="tencent://AddContact/?fromId=50&fromSubId=1&subcmd=all&uin=1543373971" class="tooltipped" target="_blank" data-tooltip="QQ联系我: 1543373971" data-position="top" data-delay="50">
        <i class="fab fa-qq"></i>
    </a>


<!-- 




    <a href="/atom.xml" class="tooltipped" target="_blank" data-tooltip="RSS 订阅" data-position="top" data-delay="50">
        <i class="fas fa-rss"></i>
    </a>

 --></div>
 -->     </div>
</footer>

<div class="progress-bar"></div>


    <!-- 搜索遮罩框 -->
<div id="searchModal" class="modal">
    <div class="modal-content">
        <div class="search-header">
            <span class="title"><i class="fas fa-search"></i>&nbsp;&nbsp;搜索</span>
            <input type="search" id="searchInput" name="s" placeholder="请输入搜索的关键字"
                   class="search-input">
        </div>
        <div id="searchResult"></div>
    </div>
</div>

<script type="text/javascript">
$(function () {
    var searchFunc = function (path, search_id, content_id) {
        'use strict';
        $.ajax({
            url: path,
            dataType: "xml",
            success: function (xmlResponse) {
                // get the contents from search data
                var datas = $("entry", xmlResponse).map(function () {
                    return {
                        title: $("title", this).text(),
                        content: $("content", this).text(),
                        url: $("url", this).text()
                    };
                }).get();
                var $input = document.getElementById(search_id);
                var $resultContent = document.getElementById(content_id);
                $input.addEventListener('input', function () {
                    var str = '<ul class=\"search-result-list\">';
                    var keywords = this.value.trim().toLowerCase().split(/[\s\-]+/);
                    $resultContent.innerHTML = "";
                    if (this.value.trim().length <= 0) {
                        return;
                    }
                    // perform local searching
                    datas.forEach(function (data) {
                        var isMatch = true;
                        var data_title = data.title.trim().toLowerCase();
                        var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
                        var data_url = data.url;
                        data_url = data_url.indexOf('/') === 0 ? data.url : '/' + data_url;
                        var index_title = -1;
                        var index_content = -1;
                        var first_occur = -1;
                        // only match artiles with not empty titles and contents
                        if (data_title !== '' && data_content !== '') {
                            keywords.forEach(function (keyword, i) {
                                index_title = data_title.indexOf(keyword);
                                index_content = data_content.indexOf(keyword);
                                if (index_title < 0 && index_content < 0) {
                                    isMatch = false;
                                } else {
                                    if (index_content < 0) {
                                        index_content = 0;
                                    }
                                    if (i === 0) {
                                        first_occur = index_content;
                                    }
                                }
                            });
                        }
                        // show search results
                        if (isMatch) {
                            str += "<li><a href='" + data_url + "' class='search-result-title'>" + data_title + "</a>";
                            var content = data.content.trim().replace(/<[^>]+>/g, "");
                            if (first_occur >= 0) {
                                // cut out 100 characters
                                var start = first_occur - 20;
                                var end = first_occur + 80;
                                if (start < 0) {
                                    start = 0;
                                }
                                if (start === 0) {
                                    end = 100;
                                }
                                if (end > content.length) {
                                    end = content.length;
                                }
                                var match_content = content.substr(start, end);
                                // highlight all keywords
                                keywords.forEach(function (keyword) {
                                    var regS = new RegExp(keyword, "gi");
                                    match_content = match_content.replace(regS, "<em class=\"search-keyword\">" + keyword + "</em>");
                                });

                                str += "<p class=\"search-result\">" + match_content + "...</p>"
                            }
                            str += "</li>";
                        }
                    });
                    str += "</ul>";
                    $resultContent.innerHTML = str;
                });
            }
        });
    };

    searchFunc('/search.xml', 'searchInput', 'searchResult');
});
</script>

    <!-- 回到顶部按钮 -->
<div id="backTop" class="top-scroll">
    <a class="btn-floating btn-large waves-effect waves-light" href="#!">
        <i class="fas fa-arrow-up"></i>
    </a>
</div>


    <script src="/libs/materialize/materialize.min.js"></script>
    <script src="/libs/masonry/masonry.pkgd.min.js"></script>
    <script src="/libs/aos/aos.js"></script>
    <script src="/libs/scrollprogress/scrollProgress.min.js"></script>
    <script src="/libs/lightGallery/js/lightgallery-all.min.js"></script>
    <script src="/js/matery.js"></script>

    

    
        
        <script type="text/javascript">
            // 只在桌面版网页启用特效
            var windowWidth = $(window).width();
            if (windowWidth > 768) {
                document.write('<script type="text/javascript" src="/libs/others/sakura.js"><\/script>');
            }
        </script>
    

    <!-- 雪花特效 -->
    

    <!-- 鼠标星星特效 -->
    

    

    <!-- Baidu Analytics -->

    <!-- Baidu Push -->

<script>
    (function () {
        var bp = document.createElement('script');
        var curProtocol = window.location.protocol.split(':')[0];
        if (curProtocol === 'https') {
            bp.src = 'https://zz.bdstatic.com/linksubmit/push.js';
        } else {
            bp.src = 'http://push.zhanzhang.baidu.com/push.js';
        }
        var s = document.getElementsByTagName("script")[0];
        s.parentNode.insertBefore(bp, s);
    })();
</script>

    
    <script src="/libs/others/clicklove.js" async="async"></script>
    
    
    <script async src="/libs/others/busuanzi.pure.mini.js"></script>
    

    

    

    <!--腾讯兔小巢-->
    
    

    

    

    
    <script src="/libs/instantpage/instantpage.js" type="module"></script>
    

</body>

</html>
